package com.linjm.service.impl;

import com.alibaba.fastjson.JSON;
import com.linjm.bean.*;
import com.linjm.mapper.*;
import com.linjm.service.SpuService;
import com.linjm.util.RedisUtil;
import org.apache.dubbo.config.annotation.DubboService;
import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import redis.clients.jedis.Jedis;

import java.util.List;
import java.util.concurrent.TimeUnit;
@DubboService
@Service
public class SpuServiceImpl implements SpuService {
    @Autowired
    private SpuInfoMapper spuInfoMapper;
    @Autowired
    private SpuImageMapper spuImageMapper;
    @Autowired
    private SpuSaleAttrMapper spuSaleAttrMapper;
    @Autowired
    private SpuSaleAttrValueMapper spuSaleAttrValueMapper;
    @Autowired
    private BaseAttrInfoMapper baseAttrInfoMapper;

    @Autowired
    private SkuInfoMapper skuInfoMapper;
    @Autowired
    private SkuImageMapper skuImageMapper;
    @Autowired
    private SkuAttrValueMapper skuAttrValueMapper;
    @Autowired
    private SkuSaleAttrValueMapper skuSaleAttrValueMapper;
    @Autowired
    private RedisUtil redisUtil;

    @Override
    public List<SpuInfo> getSpuList(SpuInfo spuInfo) {
        return spuInfoMapper.select(spuInfo);
    }

    @Override
    @Transactional
    public void saveSpuInfo(SpuInfo spuInfo) {
        //保存数据，以前没数据
        if (spuInfo.getId() == null || spuInfo.getId().length() == 0) {
            spuInfoMapper.insertSelective(spuInfo);
        } else {
            spuInfoMapper.updateByPrimaryKeySelective(spuInfo);
        }
        //更新数据
        //图片列表先删除再新增
        SpuImage spuImage = new SpuImage();
        spuImage.setSpuId(spuInfo.getId());
        spuImageMapper.delete(spuImage);

        //保存数据，先获取数据
        List<SpuImage> spuImageList = spuInfo.getSpuImageList();
        if (spuImageList != null && spuImageList.size() > 0) {
            for (SpuImage image : spuImageList) {
                image.setSpuId(spuInfo.getId());
                spuImageMapper.insertSelective(image);
            }
        }

        //销售属性，删除
        SpuSaleAttr spuSaleAttr = new SpuSaleAttr();
        spuSaleAttr.setSpuId(spuInfo.getId());
        spuSaleAttrMapper.delete(spuSaleAttr);

        //销售属性值，删除
        SpuSaleAttrValue spuSaleAttrValue = new SpuSaleAttrValue();
        spuSaleAttrValue.setSpuId(spuInfo.getId());
        spuSaleAttrValueMapper.delete(spuSaleAttrValue);

        //获取数据，插入
        List<SpuSaleAttr> spuSaleAttrList = spuInfo.getSpuSaleAttrList();
        if (spuSaleAttrList != null && spuSaleAttrList.size() > 0) {
            for (SpuSaleAttr saleAttr : spuSaleAttrList) {
                saleAttr.setSpuId(spuInfo.getId());
                spuSaleAttrMapper.insertSelective(saleAttr);

                List<SpuSaleAttrValue> spuSaleAttrValueList = saleAttr.getSpuSaleAttrValueList();
                if (spuSaleAttrValueList != null && spuSaleAttrValueList.size() > 0) {
                    for (SpuSaleAttrValue saleAttrValue : spuSaleAttrValueList) {
                        saleAttrValue.setId(null);
                        saleAttrValue.setSpuId(spuInfo.getId());
                        spuSaleAttrValueMapper.insertSelective(saleAttrValue);
                    }
                }
            }
        }


    }


    @Override
    public List<SpuImage> getSpuImageList(SpuImage spuImage) {
        return spuImageMapper.select(spuImage);
    }

    @Override
    public List<SpuSaleAttr> getSpuSaleAttrList(String spuId) {
        return spuSaleAttrMapper.selectSpuSaleAttrList(spuId);
    }

    @Override
    @Transactional
    public void saveSkuInfo(SkuInfo skuInfo) {
        //skuinfo
        skuInfoMapper.insertSelective(skuInfo);
        //skuimage
        List<SkuImage> skuImageList = skuInfo.getSkuImageList();
        if (skuImageList != null && skuImageList.size() > 0) {
            for (SkuImage skuImage : skuImageList) {
                skuImage.setSkuId(skuInfo.getId());
                skuImageMapper.insertSelective(skuImage);
            }
        }
        //skuAttrValue
        List<SkuAttrValue> skuAttrValueList = skuInfo.getSkuAttrValueList();
        if (skuAttrValueList != null && skuAttrValueList.size() > 0) {
            for (SkuAttrValue skuAttrValue : skuAttrValueList) {
                skuAttrValue.setSkuId(skuInfo.getId());
                skuAttrValueMapper.insertSelective(skuAttrValue);
            }
        }
        //skuSaleAttrValue
        List<SkuSaleAttrValue> skuSaleAttrValueList = skuInfo.getSkuSaleAttrValueList();
        if (skuSaleAttrValueList != null && skuSaleAttrValueList.size() > 0) {
            for (SkuSaleAttrValue skuSaleAttrValue : skuSaleAttrValueList) {

                skuSaleAttrValue.setSkuId(skuInfo.getId());
                skuSaleAttrValueMapper.insertSelective(skuSaleAttrValue);
            }
        }
    }

    @Override
    public SkuInfo getSkuInfo(String skuId) {

        /*SkuInfo skuInfo=null;
        Jedis jedis = null;
        try {
            jedis = redisUtil.getJedis();
            String skuKey="sku:"+skuId+":info";
            //取出缓存key中的value
            String skuJson = jedis.get(skuKey);
            //如果redis和DB中都没有数据的情况，缓存穿透
            if (skuJson==null || skuJson.length()==0){
                //加锁set nx ex
                System.out.println("缓存中没有数据");
                String skuLockKey="sku:"+skuId+":lock";
                String lockKey = jedis.set(skuLockKey, "lock01", "nx", "ex", 10);
                if ("OK".equals(lockKey)){
                    //此时加锁成功
                    System.out.println("获取锁");
                    skuInfo=getSkuInfoDB(skuId);
                    //将数据转换成字符串并放入redis并设置过期时间
                    jedis.setex(skuKey,24*60*60,JSON.toJSONString(skuInfo));
                    jedis.close();
                    //删除锁
                    jedis.del(skuLockKey);
                    return skuInfo;
                }else {
                    System.out.println("等待");
                    Thread.sleep(1000);
                    return getSkuInfo(skuId);
                }

            }else {
                //有数据
                skuInfo=JSON.parseObject(skuJson,SkuInfo.class);
                jedis.close();
                return skuInfo;
        }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return getSkuInfoDB(skuId);
*/
        return getSkuInfoRedisson(skuId);

    }

    public SkuInfo getSkuInfoRedisson(String skuId){

        // 放入业务逻辑代码
        SkuInfo skuInfo =null;
        try (Jedis jedis = redisUtil.getJedis()) {
            String skuKey = "sku:" + skuId + ":info";
            if (jedis.exists(skuKey)) {
                // 取得key 中的value
                String skuJson = jedis.get(skuKey);
                // 将字符串转换为对象
                skuInfo = JSON.parseObject(skuJson, SkuInfo.class);
                System.out.println("调用redis数据");
                jedis.close();
                return skuInfo;

            } else {
                Config config = new Config();
                config.useSingleServer().setAddress("redis://192.168.1.10:6379");
                RedissonClient redissonClient = Redisson.create(config);
                // 使用redisson 调用getLock
                RLock lock = redissonClient.getLock("lock");
                // 加锁
                lock.lock(10, TimeUnit.SECONDS);

                try {
                    skuInfo = getSkuInfoDB(skuId);
                    //将数据转换成字符串并放入redis并设置过期时间
                    jedis.setex(skuKey, 24 * 60 * 60, JSON.toJSONString(skuInfo));
                    System.out.println("调用数据库DB 并把数据写入redis");
                    jedis.close();
                    return skuInfo;
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {

                    lock.unlock();
                }


            }

        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("redis异常");
        }


        return getSkuInfoDB(skuId);

    }

    private SkuInfo getSkuInfoDB(String skuId) {
        SkuInfo skuInfo = skuInfoMapper.selectByPrimaryKey(skuId);
        //查询平台属性值
        SkuAttrValue skuAttrValue = new SkuAttrValue();
        skuAttrValue.setSkuId(skuId);
        List<SkuAttrValue> skuAttrValueList = skuAttrValueMapper.select(skuAttrValue);
        skuInfo.setSkuAttrValueList(skuAttrValueList);
        return skuInfo;
    }

    @Override
    public List<SkuImage> getSkuImageList(String skuId) {
        SkuImage skuImage = new SkuImage();
        skuImage.setSkuId(skuId);
        return skuImageMapper.select(skuImage);
    }

    @Override
    public List<SpuSaleAttr> getSpuSaleAttrListCheckBySku(SkuInfo skuInfo) {
        return spuSaleAttrMapper.getSpuSaleAttrListCheckBySku(skuInfo.getId(),skuInfo.getSpuId());
    }

    @Override
    public List<SkuSaleAttrValue> getSpuSaleAttrListCheckBySpu(String spuId) {
        return spuSaleAttrValueMapper.getSpuSaleAttrListCheckBySpu(spuId);
    }

}
